package com.genersoft.iot.vmp.vmanager.record;


import com.genersoft.iot.vmp.gb28181.transmit.request.impl.InviteRequestProcessor;

import java.io.*;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

import static com.genersoft.iot.vmp.vmanager.record.CalculateUtil.intToByte;
import static com.genersoft.iot.vmp.vmanager.record.CalculateUtil.memset;

public class RtspPacketEncode {
    private static final String TAG = "RtspPacketEncode";

    //------------视频转换数据监听-----------
    public interface H264ToRtpLinsener {
        void h264ToRtpResponse(byte[] out, int len);
    }

    private H264ToRtpLinsener h264ToRtpLinsener;

    //执行回调
    private void exceuteH264ToRtpLinsener(byte[] out, int len) {
//        if (this.h264ToRtpLinsener != null) {
//            h264ToRtpLinsener.h264ToRtpResponse(out, len);
//        }
    }

    // -------音频--------
    private int framerate = 20;
//    private byte[] sendbuf = new byte[400];
    private byte[] sendbuf = new byte[1500];
    private int packageSize = 1400;
//    private int packageSize = 384;
    private int seq_num = 0;
    //private int timestamp_increse = (int) (90000.0 / framerate);//framerate是帧率
    private int timestamp_increse = (int) (8000.0 / framerate);//framerate是帧率 时间戳增量
    private int ts_current = 0;
    private int bytes = 0;

    // -------视频END--------

//    public RtspPacketEncode(H264ToRtpLinsener h264ToRtpLinsener) {
//        this.h264ToRtpLinsener = h264ToRtpLinsener;
//    }



    /**
     * 一帧一帧的RTP封包
     *
     * @param r
     * @return
     */
    public void h264ToRtp(byte[] r, int h264len, OutputStream outputStream) throws Exception {
        h264len = 1484;
        String port0= InviteRequestProcessor.port1;
        Integer port=Integer.valueOf(port0);

        long teststart = System.currentTimeMillis();

        System.out.println("开始时间：" + teststart);




        memset(sendbuf, 0, 1500);
        System.arraycopy(intToByte(1500), 0, sendbuf, 0, 4);//共四位
        {
            byte temp = 0;
            temp = sendbuf[0];
            sendbuf[0] = sendbuf[3];
            sendbuf[3] = temp;
            temp = sendbuf[1];
            sendbuf[1] = sendbuf[2];
            sendbuf[2] = temp;
        }
      /*  System.arraycopy(CalculateUtil.intToByte(1416), 0, sendbuf, 0, 2);//send[2]和send[3]为序列号，共两位
        {
            // java默认的网络字节序是大端字节序（无论在什么平台上），因为windows为小字节序，所以必须倒序
            *//**参考：
             * http://blog.csdn.net/u011068702/article/details/51857557
             * http://cpjsjxy.iteye.com/blog/1591261
             *//*
            byte temp = 0;
            temp = sendbuf[0];
            sendbuf[0] = sendbuf[1];
            sendbuf[1] = temp;
        }*/
        //CalculateUtil.memset(sendbuf, 0, 400);
        sendbuf[5] = (byte) (sendbuf[5] | 0x90); // 负载类型号96,其值为：01100000
        sendbuf[4] = (byte) (sendbuf[4] | 0x80); // 版本号,此版本固定为2
        sendbuf[5] = (byte) (sendbuf[5] & 254); //标志位，由具体协议规定其值，其值为：01100000
        sendbuf[15] = 10;//随机指定10，并在本RTP回话中全局唯一,java默认采用网络字节序号 不用转换（同源标识符的最后一个字节）
        if (h264len <= packageSize) {
            sendbuf[5] = (byte) (sendbuf[1] | 0x80); // 设置rtp M位为1，其值为：11100000，分包的最后一片，M位（第一位）为0，后7位是十进制的96，表示负载类型
            sendbuf[7] = (byte) seq_num++;
            System.arraycopy(intToByte(seq_num++), 0, sendbuf, 6, 2);//send[2]和send[3]为序列号，共两位
            {
                // java默认的网络字节序是大端字节序（无论在什么平台上），因为windows为小字节序，所以必须倒序
                /**参考：
                 * http://blog.csdn.net/u011068702/article/details/51857557
                 * http://cpjsjxy.iteye.com/blog/1591261
                 */
                byte temp = 0;
                temp = sendbuf[3+4];
                sendbuf[3+4] = sendbuf[2+4];
                sendbuf[2+4] = temp;
            }
            // FU-A HEADER, 并将这个HEADER填入sendbuf[12]
            sendbuf[12+4] = (byte) (sendbuf[12+4] | ((byte) (r[0] & 0x80)) << 7);
            sendbuf[12+4] = (byte) (sendbuf[12+4] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
            sendbuf[12+4] = (byte) (sendbuf[12+4] | ((byte) (r[0] & 0x1f)));
            // 同理将sendbuf[13]赋给nalu_payload
            //NALU头已经写到sendbuf[12]中，接下来则存放的是NAL的第一个字节之后的数据。所以从r的第二个字节开始复制
            System.arraycopy(r, 1, sendbuf, 13+4, h264len - 1);
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4+4, 4);//序列号接下来是时间戳，4个字节，存储后也需要倒序
            {
                byte temp = 0;
                temp = sendbuf[4+4];
                sendbuf[4+4] = sendbuf[7+4];
                sendbuf[7+4] = temp;
                temp = sendbuf[5+4];
                sendbuf[5+4] = sendbuf[6+4];
                sendbuf[6+4] = temp;
            }
            bytes = h264len + 12+4;//获sendbuf的长度,为nalu的长度(包含nalu头但取出起始前缀,加上rtp_header固定长度12个字节)
            //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
            //send(sendbuf,bytes);
            //exceuteH264ToRtpLinsener(sendbuf, bytes);
            System.out.println("已发送第个字节数组："+bytes);
            outputStream.write(sendbuf);
            outputStream.flush();


        } else if (h264len > packageSize) {
            int k = 0, l = 0;
            k = h264len / packageSize;
            l = h264len % packageSize;
            int t = 0;
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4+4, 4);//时间戳，并且倒序
            {
                byte temp = 0;
                temp = sendbuf[4+4];
                sendbuf[4+4] = sendbuf[7+4];
                sendbuf[7+4] = temp;
                temp = sendbuf[5+4];
                sendbuf[5+4] = sendbuf[6+4];
                sendbuf[6+4] = temp;
            }
            while (t <= k) {
                System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2+4, 2);//序列号，并且倒序
                {
                    byte temp = 0;
                    temp = sendbuf[3+4];
                    sendbuf[3+4] = sendbuf[2+4];
                    sendbuf[2+4] = temp;
                }
                if (t == 0) {//分包的第一片
                    sendbuf[1+4] = (byte) (sendbuf[1+4] & 0x7F);//其值为：01100000，不是最后一片，M位（第一位）设为0
                    //FU indicator，一个字节，紧接在RTP header之后，包括F,NRI，header
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);//禁止位，为0
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);//NRI，表示包的重要性
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));//TYPE，表示此FU-A包为什么类型，一般此处为28
//                    //FU header，一个字节，S,E，R，TYPE
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xBF);//E=0，表示是否为最后一个包，是则为1
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF);//R=0，保留位，必须设置为0
//                    sendbuf[13] = (byte) (sendbuf[13] | 0x80);//S=1，表示是否为第一个包，是则为1
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//TYPE，即NALU头对应的TYPE
                    //将除去NALU头剩下的NALU数据写入sendbuf的第14个字节之后。前14个字节包括：12字节的RTP Header，FU indicator，FU header
                    System.arraycopy(r, 1, sendbuf, 12+4, packageSize);
                    //client.send(new DatagramPacket(sendbuf, packageSize + 14, addr, port/*9200*/));
                    //exceuteH264ToRtpLinsener(sendbuf, packageSize + 14);
                    System.out.println("已发送第"+t+"个字节数组："+(packageSize+16));
                    outputStream.write(sendbuf);
                    outputStream.flush();

                    t++;
                } else if (t == k) {//分片的最后一片
                    sendbuf[1+4] = (byte) (sendbuf[1+4] | 0x80);

//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));
//
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF); //R=0，保留位必须设为0
//                    sendbuf[13] = (byte) (sendbuf[13] & 0x7F); //S=0，不是第一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | 0x40); //E=1，是最后一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//NALU头对应的type

                    if (0 != l) {//如果不能整除，则有剩下的包，执行此代码。如果包大小恰好是1400的倍数，不执行此代码。
                        System.arraycopy(r, t * packageSize + 1, sendbuf, 12+4, l - 1);//l-1，不包含NALU头
                        bytes = l - 1 + 12 +4; //bytes=l-1+14;
                        //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
                        //send(sendbuf,bytes);
                        //exceuteH264ToRtpLinsener(sendbuf, bytes);
                        System.out.println("已发送第"+t+"个字节数组："+bytes);
                        outputStream.write(sendbuf);
                        outputStream.flush();

                    }//pl
                    t++;
                } else if (t < k && 0 != t) {//既不是第一片，又不是最后一片的包
                    sendbuf[1+4] = (byte) (sendbuf[1+4] & 0x7F); //M=0，其值为：01100000，不是最后一片，M位（第一位）设为0.
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));
//
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF); //R=0，保留位必须设为0
//                    sendbuf[13] = (byte) (sendbuf[13] & 0x7F); //S=0，不是第一个包
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xBF); //E=0，不是最后一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//NALU头对应的type
                    System.arraycopy(r, t * packageSize + 1, sendbuf, 12+4, packageSize);//不包含NALU头
                    //client.send(new DatagramPacket(sendbuf, packageSize + 14, addr, port/*9200*/));
                    //send(sendbuf,1414);
                    //exceuteH264ToRtpLinsener(sendbuf, packageSize + 14);
                    System.out.println("已发送第"+t+"个字节数组："+(packageSize + 16));
                    outputStream.write(sendbuf);
                    outputStream.flush();

                    t++;
                }

            }
            System.out.println("发送个数：" + t);

        }
        long testend = System.currentTimeMillis();
        System.out.println("发送用时：" + (testend - teststart));
        System.out.println("结束时间：" + testend);
    }


    /**
     * 一帧一帧的RTP封包
     *
     * @param r
     * @return
     */
    public void h264ToRtp2(byte[] r, int h264len) throws Exception {

        DatagramSocket ds=new DatagramSocket(8000);
        String port0= InviteRequestProcessor.port1;
        Integer port=Integer.valueOf(port0);
        long teststart = System.currentTimeMillis();
        System.out.println("开始时间：" + teststart);

        //CalculateUtil.memset(sendbuf, 0, 1500);
        memset(sendbuf, 0, 400);
        //sendbuf[1] = (byte) (sendbuf[1] | 96); // 负载类型号96,视频 其值为：01100000
        //sendbuf[1] = (byte) (sendbuf[1] | 8); // 负载类型号8,音频其值为：01100000
        sendbuf[1] = (byte) (sendbuf[1] | 0x90); // 建议96 表示PS 封装，建议97 为MPEG-4，建议98 为H264
        sendbuf[0] = (byte) (sendbuf[0] | 0x80); // 版本号,此版本固定为2
        sendbuf[1] = (byte) (sendbuf[1] & 254); //标志位，由具体协议规定其值，其值为：01100000
        sendbuf[11] = 10;//随机指定10，并在本RTP回话中全局唯一,java默认采用网络字节序号 不用转换（同源标识符的最后一个字节）
        if (h264len <= packageSize) {
            sendbuf[1] = (byte) (sendbuf[1] | 0x80); // 设置rtp M位为1，其值为：11100000，分包的最后一片，M位（第一位）为0，后7位是十进制的96，表示负载类型
            sendbuf[3] = (byte) seq_num++;
            System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2, 2);//send[2]和send[3]为序列号，共两位
            {
                // java默认的网络字节序是大端字节序（无论在什么平台上），因为windows为小字节序，所以必须倒序
                /**参考：
                 * http://blog.csdn.net/u011068702/article/details/51857557
                 * http://cpjsjxy.iteye.com/blog/1591261
                 */
                byte temp = 0;
                temp = sendbuf[3];
                sendbuf[3] = sendbuf[2];
                sendbuf[2] = temp;
            }
            // FU-A HEADER, 并将这个HEADER填入sendbuf[12]
            sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
            sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
            sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x1f)));
            // 同理将sendbuf[13]赋给nalu_payload
            //NALU头已经写到sendbuf[12]中，接下来则存放的是NAL的第一个字节之后的数据。所以从r的第二个字节开始复制
            System.arraycopy(r, 1, sendbuf, 13, h264len - 1);
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4, 4);//序列号接下来是时间戳，4个字节，存储后也需要倒序
            {
                byte temp = 0;
                temp = sendbuf[4];
                sendbuf[4] = sendbuf[7];
                sendbuf[7] = temp;
                temp = sendbuf[5];
                sendbuf[5] = sendbuf[6];
                sendbuf[6] = temp;
            }
            bytes = h264len + 12;//获sendbuf的长度,为nalu的长度(包含nalu头但取出起始前缀,加上rtp_header固定长度12个字节)
            //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
            //send(sendbuf,bytes);
            //exceuteH264ToRtpLinsener(sendbuf, bytes);
            System.out.println("已发送第个字节数组：");
            //test.rtpSession.sendData(sendbuf);
            InetAddress inetAddress=InetAddress.getByName("192.168.0.104");
            DatagramPacket dp=new DatagramPacket(sendbuf,bytes,inetAddress,port);
            ds.send(dp);
        } else if (h264len > packageSize) {
            int k = 0, l = 0;
            k = h264len / packageSize;
            l = h264len % packageSize;
            int t = 0;
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4, 4);//时间戳，并且倒序
            {
                byte temp = 0;
                temp = sendbuf[4];
                sendbuf[4] = sendbuf[7];
                sendbuf[7] = temp;
                temp = sendbuf[5];
                sendbuf[5] = sendbuf[6];
                sendbuf[6] = temp;
            }
            while (t <= k) {
                System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2, 2);//序列号，并且倒序
                {
                    byte temp = 0;
                    temp = sendbuf[3];
                    sendbuf[3] = sendbuf[2];
                    sendbuf[2] = temp;
                }
                if (t == 0) {//分包的第一片
                    //sendbuf[1] = (byte) (sendbuf[1] & 0x7F);//其值为：01100000，不是最后一片，M位（第一位）设为0
                    sendbuf[1] = (byte) (sendbuf[1] & 0);//其值为：01100000，不是最后一片，M位（第一位）设为0
                    //FU indicator，一个字节，紧接在RTP header之后，包括F,NRI，header
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);//禁止位，为0
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);//NRI，表示包的重要性
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));//TYPE，表示此FU-A包为什么类型，一般此处为28
                    //FU header，一个字节，S,E，R，TYPE
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xBF);//E=0，表示是否为最后一个包，是则为1
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF);//R=0，保留位，必须设置为0
//                    sendbuf[13] = (byte) (sendbuf[13] | 0x80);//S=1，表示是否为第一个包，是则为1
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//TYPE，即NALU头对应的TYPE
                    //将除去NALU头剩下的NALU数据写入sendbuf的第14个字节之后。前14个字节包括：12字节的RTP Header，FU indicator，FU header
                    //System.arraycopy(r, 1, sendbuf, 14, packageSize);视频14音频12
                    System.arraycopy(r, 1, sendbuf, 12, packageSize);
                    //client.send(new DatagramPacket(sendbuf, packageSize + 14, addr, port/*9200*/));
                    //exceuteH264ToRtpLinsener(sendbuf, packageSize + 14);
                    System.out.println("已发送第"+t+"个字节数组：");
                    //test.rtpSession.sendData(sendbuf);
                    InetAddress inetAddress=InetAddress.getByName("192.168.0.104");
                    DatagramPacket dp=new DatagramPacket(sendbuf,bytes,inetAddress,port);
                    ds.send(dp);
                    t++;
                } else if (t == k) {//分片的最后一片
                    //sendbuf[1] = (byte) (sendbuf[1] | 0x80);
                    sendbuf[1] = (byte) (sendbuf[1] & 0);//其值为：01100000，不是最后一片，M位（第一位）设为0
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));
//
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF); //R=0，保留位必须设为0
//                    sendbuf[13] = (byte) (sendbuf[13] & 0x7F); //S=0，不是第一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | 0x40); //E=1，是最后一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//NALU头对应的type

                    if (0 != l) {//如果不能整除，则有剩下的包，执行此代码。如果包大小恰好是1400的倍数，不执行此代码。
                        System.arraycopy(r, t * packageSize + 1, sendbuf, 14, l - 1);//l-1，不包含NALU头
                        bytes = l - 1 + 14; //bytes=l-1+14;
                        //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
                        //send(sendbuf,bytes);
                        //exceuteH264ToRtpLinsener(sendbuf, bytes);
                        System.out.println("已发送第"+t+"个字节数组：");
                        //test.rtpSession.sendData(sendbuf);
                        InetAddress inetAddress=InetAddress.getByName("192.168.0.104");
                        DatagramPacket dp=new DatagramPacket(sendbuf,bytes,inetAddress,port);
                        ds.send(dp);
                    }//pl
                    t++;
                } else if (t < k && 0 != t) {//既不是第一片，又不是最后一片的包
                    //sendbuf[1] = (byte) (sendbuf[1] & 0x7F); //M=0，其值为：01100000，不是最后一片，M位（第一位）设为0.
                    sendbuf[1] = (byte) (sendbuf[1] & 0);//其值为：01100000，不是最后一片，M位（第一位）设为0
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));
//
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF); //R=0，保留位必须设为0
//                    sendbuf[13] = (byte) (sendbuf[13] & 0x7F); //S=0，不是第一个包
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xBF); //E=0，不是最后一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//NALU头对应的type
                    //System.arraycopy(r, t * packageSize + 1, sendbuf, 14, packageSize);//不包含NALU头 视频
                    System.arraycopy(r, t * packageSize + 1, sendbuf, 12, packageSize);//不包含NALU头 音频
                    //client.send(new DatagramPacket(sendbuf, packageSize + 14, addr, port/*9200*/));
                    //send(sendbuf,1414);
                    //exceuteH264ToRtpLinsener(sendbuf, packageSize + 14);
                    System.out.println("已发送第"+t+"个字节数组："+sendbuf);
                    //test.rtpSession.sendData(sendbuf);
                    InetAddress inetAddress=InetAddress.getByName("192.168.0.104");
                    //DatagramPacket dp=new DatagramPacket(sendbuf,bytes,inetAddress,port);
                    DatagramPacket dp=new DatagramPacket(sendbuf,412,inetAddress,port);
                    ds.send(dp);
                    t++;
                }
            }
        }
        long testend = System.currentTimeMillis();
        System.out.println("发送用时：" + (testend - teststart));
        System.out.println("结束时间：" + testend);
    }


    /**
     * 一帧一帧的RTP封包
     *
     * @param r
     * @return
     */
    public void h264ToRtp3(byte[] r, int h264len, OutputStream outputStream) throws Exception {
        h264len = 1500-16;
        String port0= InviteRequestProcessor.port1;
        Integer port=Integer.valueOf(port0);

        long teststart = System.currentTimeMillis();

        System.out.println("开始时间：" + teststart);




        memset(sendbuf, 0, 1500);
        //CalculateUtil.memset(sendbuf, 0, 400);
        sendbuf[1] = (byte) (sendbuf[1] | 0x90); // 负载类型号96,其值为：01100000
        sendbuf[0] = (byte) (sendbuf[0] | 0x80); // 版本号,此版本固定为2
        sendbuf[1] = (byte) (sendbuf[1] & 254); //标志位，由具体协议规定其值，其值为：01100000
        sendbuf[11] = 10;//随机指定10，并在本RTP回话中全局唯一,java默认采用网络字节序号 不用转换（同源标识符的最后一个字节）
        if (h264len <= packageSize) {
            sendbuf[1] = (byte) (sendbuf[1] | 0x80); // 设置rtp M位为1，其值为：11100000，分包的最后一片，M位（第一位）为0，后7位是十进制的96，表示负载类型
            sendbuf[3] = (byte) seq_num++;
            System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2, 2);//send[2]和send[3]为序列号，共两位
            {
                // java默认的网络字节序是大端字节序（无论在什么平台上），因为windows为小字节序，所以必须倒序
                /**参考：
                 * http://blog.csdn.net/u011068702/article/details/51857557
                 * http://cpjsjxy.iteye.com/blog/1591261
                 */
                byte temp = 0;
                temp = sendbuf[3];
                sendbuf[3] = sendbuf[2];
                sendbuf[2] = temp;
            }
            // FU-A HEADER, 并将这个HEADER填入sendbuf[12]
            sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
            sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
            sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x1f)));
            // 同理将sendbuf[13]赋给nalu_payload
            //NALU头已经写到sendbuf[12]中，接下来则存放的是NAL的第一个字节之后的数据。所以从r的第二个字节开始复制
            System.arraycopy(r, 1, sendbuf, 13, h264len - 1);
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4, 4);//序列号接下来是时间戳，4个字节，存储后也需要倒序
            {
                byte temp = 0;
                temp = sendbuf[4];
                sendbuf[4] = sendbuf[7];
                sendbuf[7] = temp;
                temp = sendbuf[5];
                sendbuf[5] = sendbuf[6];
                sendbuf[6] = temp;
            }
            bytes = h264len + 12;//获sendbuf的长度,为nalu的长度(包含nalu头但取出起始前缀,加上rtp_header固定长度12个字节)
            //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
            //send(sendbuf,bytes);
            //exceuteH264ToRtpLinsener(sendbuf, bytes);
            System.out.println("已发送第个字节数组：");
            outputStream.write(sendbuf);
            outputStream.flush();


        } else if (h264len > packageSize) {
            int k = 0, l = 0;
            k = h264len / packageSize;
            l = h264len % packageSize;
            int t = 0;
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4, 4);//时间戳，并且倒序
            {
                byte temp = 0;
                temp = sendbuf[4];
                sendbuf[4] = sendbuf[7];
                sendbuf[7] = temp;
                temp = sendbuf[5];
                sendbuf[5] = sendbuf[6];
                sendbuf[6] = temp;
            }
            while (t <= k) {
                System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2, 2);//序列号，并且倒序
                {
                    byte temp = 0;
                    temp = sendbuf[3];
                    sendbuf[3] = sendbuf[2];
                    sendbuf[2] = temp;
                }
                if (t == 0) {//分包的第一片
                    sendbuf[1] = (byte) (sendbuf[1] & 0x7F);//其值为：01100000，不是最后一片，M位（第一位）设为0
                    //FU indicator，一个字节，紧接在RTP header之后，包括F,NRI，header
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);//禁止位，为0
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);//NRI，表示包的重要性
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));//TYPE，表示此FU-A包为什么类型，一般此处为28
//                    //FU header，一个字节，S,E，R，TYPE
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xBF);//E=0，表示是否为最后一个包，是则为1
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF);//R=0，保留位，必须设置为0
//                    sendbuf[13] = (byte) (sendbuf[13] | 0x80);//S=1，表示是否为第一个包，是则为1
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//TYPE，即NALU头对应的TYPE
                    //将除去NALU头剩下的NALU数据写入sendbuf的第14个字节之后。前14个字节包括：12字节的RTP Header，FU indicator，FU header
                    System.arraycopy(r, 1, sendbuf, 12, packageSize);
                    //client.send(new DatagramPacket(sendbuf, packageSize + 14, addr, port/*9200*/));
                    //exceuteH264ToRtpLinsener(sendbuf, packageSize + 14);
                    System.out.println("已发送第"+t+"个字节数组：");
                    outputStream.write(sendbuf);
                    outputStream.flush();

                    t++;
                } else if (t == k) {//分片的最后一片
                    sendbuf[1] = (byte) (sendbuf[1] | 0x80);

//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));
//
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF); //R=0，保留位必须设为0
//                    sendbuf[13] = (byte) (sendbuf[13] & 0x7F); //S=0，不是第一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | 0x40); //E=1，是最后一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//NALU头对应的type

                    if (0 != l) {//如果不能整除，则有剩下的包，执行此代码。如果包大小恰好是1400的倍数，不执行此代码。
                        System.arraycopy(r, t * packageSize + 1, sendbuf, 12, l - 1);//l-1，不包含NALU头
                        bytes = l - 1 + 12; //bytes=l-1+14;
                        //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
                        //send(sendbuf,bytes);
                        //exceuteH264ToRtpLinsener(sendbuf, bytes);
                        System.out.println("已发送第"+t+"个字节数组：");
                        outputStream.write(sendbuf);
                        outputStream.flush();

                    }//pl
                    t++;
                } else if (t < k && 0 != t) {//既不是第一片，又不是最后一片的包
                    sendbuf[1] = (byte) (sendbuf[1] & 0x7F); //M=0，其值为：01100000，不是最后一片，M位（第一位）设为0.
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) (r[0] & 0x80)) << 7);
//                    sendbuf[12] = (byte) (sendbuf[12] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
//                    sendbuf[12] = (byte) (sendbuf[12] | (byte) (28));
//
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xDF); //R=0，保留位必须设为0
//                    sendbuf[13] = (byte) (sendbuf[13] & 0x7F); //S=0，不是第一个包
//                    sendbuf[13] = (byte) (sendbuf[13] & 0xBF); //E=0，不是最后一个包
//                    sendbuf[13] = (byte) (sendbuf[13] | ((byte) (r[0] & 0x1f)));//NALU头对应的type
                    System.arraycopy(r, t * packageSize + 1, sendbuf, 12, packageSize);//不包含NALU头
                    //client.send(new DatagramPacket(sendbuf, packageSize + 14, addr, port/*9200*/));
                    //send(sendbuf,1414);
                    //exceuteH264ToRtpLinsener(sendbuf, packageSize + 14);
                    System.out.println("已发送第"+t+"个字节数组：");
                    try {
                        outputStream.write(sendbuf);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    outputStream.flush();

                    t++;
                }
            }
            System.out.println("发送个数：" + t);

        }
        long testend = System.currentTimeMillis();
        System.out.println("发送用时：" + (testend - teststart));
        System.out.println("结束时间：" + testend);
    }

    public void h264ToRtpOverTcpAddLength(byte[] r, int h264len, OutputStream outputStream) throws Exception {
        memset(this.sendbuf, 0, 400);
        int psize = 2;
        //包长
        System.arraycopy(intToByte(400 - psize), 0, this.sendbuf, 0, psize);

        byte temp = 0;
        temp = this.sendbuf[0];
        this.sendbuf[0] = this.sendbuf[1];
        this.sendbuf[1] = temp;
        this.sendbuf[1 + psize] = (byte)(this.sendbuf[1 + psize] | 96);
        this.sendbuf[0 + psize] = (byte)(this.sendbuf[0 + psize] | 0x80);
        this.sendbuf[1 + psize] = (byte)(this.sendbuf[1 + psize] & 254);
        this.sendbuf[11 + psize] = 10;
        if (h264len <= this.packageSize) {
            this.sendbuf[1 + psize] = (byte)(this.sendbuf[1 + psize] | 0x80);
            this.sendbuf[3 + psize] = (byte)this.seq_num++;
            System.arraycopy(intToByte(this.seq_num++), 0, this.sendbuf, 2 + psize, 2);
            temp = this.sendbuf[3 + psize];
            this.sendbuf[3 + psize] = this.sendbuf[2 + psize];
            this.sendbuf[2 + psize] = temp;
            this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)(r[0] & 0x80) << 7);
            this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)((r[0] & 0x60) >> 5) << 5);
            this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)(r[0] & 0x1F));
            System.arraycopy(r, 1, this.sendbuf, 13 + psize, h264len - 1);
            this.ts_current += this.timestamp_increse;
            System.arraycopy(intToByte(this.ts_current), 0, this.sendbuf, 4 + psize, 4);
            temp = this.sendbuf[4 + psize];
            this.sendbuf[4 + psize] = this.sendbuf[7 + psize];
            this.sendbuf[7 + psize] = temp;
            temp = this.sendbuf[5 + psize];
            this.sendbuf[5 + psize] = this.sendbuf[6 + psize];
            this.sendbuf[6 + psize] = temp;
            outputStream.write(this.sendbuf);
        } else if (h264len > this.packageSize) {
            int k = 0, l = 0;
            k = h264len / this.packageSize;
            l = h264len % this.packageSize;
            int t = 0;
            this.ts_current += this.timestamp_increse;
            System.arraycopy(intToByte(this.ts_current), 0, this.sendbuf, 4 + psize, 4);
            byte b = 0;
            b = this.sendbuf[4 + psize];
            this.sendbuf[4 + psize] = this.sendbuf[7 + psize];
            this.sendbuf[7 + psize] = b;
            b = this.sendbuf[5 + psize];
            this.sendbuf[5 + psize] = this.sendbuf[6 + psize];
            this.sendbuf[6 + psize] = b;
            while (t <= k) {
                System.arraycopy(intToByte(400 - psize), 0, this.sendbuf, 0, psize);
                b = 0;
                b = this.sendbuf[0];
                this.sendbuf[0] = this.sendbuf[1];
                this.sendbuf[1] = b;
                System.arraycopy(intToByte(this.seq_num++), 0, this.sendbuf, 2 + psize, 2);
                b = 0;
                b = this.sendbuf[3 + psize];
                this.sendbuf[3 + psize] = this.sendbuf[2 + psize];
                this.sendbuf[2 + psize] = b;
                if (t == 0) {
                    this.sendbuf[1 + psize] = (byte)(this.sendbuf[1 + psize] & Byte.MAX_VALUE);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)(r[0] & 0x80) << 7);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)((r[0] & 0x60) >> 5) << 5);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | 0x1C);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & 0xBF);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & 0xDF);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] | 0x80);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] | (byte)(r[0] & 0x1F));
                    System.arraycopy(r, 1, this.sendbuf, 14 + psize, this.packageSize);
                    outputStream.write(this.sendbuf);
                    t++;
                    continue;
                }
                if (t == k) {
                    this.sendbuf[1 + psize] = (byte)(this.sendbuf[1 + psize] | 0x80);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)(r[0] & 0x80) << 7);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)((r[0] & 0x60) >> 5) << 5);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | 0x1C);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & 0xDF);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & Byte.MAX_VALUE);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] | 0x40);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] | (byte)(r[0] & 0x1F));
                    if (0 != l) {
                        System.arraycopy(r, t * this.packageSize + 1, this.sendbuf, 14 + psize, l - 1);
                        this.bytes = l - 1 + 14;
                        outputStream.write(this.sendbuf);
                    }
                    t++;
                    continue;
                }
                if (t < k && 0 != t) {
                    this.sendbuf[1 + psize] = (byte)(this.sendbuf[1 + psize] & Byte.MAX_VALUE);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)(r[0] & 0x80) << 7);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | (byte)((r[0] & 0x60) >> 5) << 5);
                    this.sendbuf[12 + psize] = (byte)(this.sendbuf[12 + psize] | 0x1C);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & 0xDF);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & Byte.MAX_VALUE);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] & 0xBF);
                    this.sendbuf[13 + psize] = (byte)(this.sendbuf[13 + psize] | (byte)(r[0] & 0x1F));
                    System.arraycopy(r, t * this.packageSize + 1, this.sendbuf, 14 + psize, this.packageSize);
                    outputStream.write(this.sendbuf);
                    t++;
                }
            }
        }
    }

    public void sendData(byte[] r, int h264len,OutputStream outputStream) throws IOException {

        memset(sendbuf, 0, 1500);

        int psize = 2;
        //包长
        System.arraycopy(intToByte(1500 - psize), 0, this.sendbuf, 0, psize);
        {
            byte temp = 0;
            temp = this.sendbuf[0];
            this.sendbuf[0] = this.sendbuf[1];
            this.sendbuf[1] = temp;
        }

        sendbuf[1+psize] = (byte) (sendbuf[1+psize] | 96); // 负载类型号96,其值为：01100000
        sendbuf[0+psize] = (byte) (sendbuf[0+psize] | 0x80); // 版本号,此版本固定为2
        sendbuf[1+psize] = (byte) (sendbuf[1+psize] & 254); //标志位，由具体协议规定其值，其值为：01100000
        sendbuf[11+psize] = 10;//随机指定10，并在本RTP回话中全局唯一,java默认采用网络字节序号 不用转换（同源标识符的最后一个字节）
        if (h264len <= packageSize) {
            sendbuf[1+psize] = (byte) (sendbuf[1+psize] | 0x80); // 设置rtp M位为1，其值为：11100000，分包的最后一片，M位（第一位）为0，后7位是十进制的96，表示负载类型
            System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2+psize, 2);//send[2]和send[3]为序列号，共两位
            {
                byte temp = 0;
                temp = sendbuf[3+psize];
                sendbuf[3+psize] = sendbuf[2+psize];
                sendbuf[2+psize] = temp;
            }
            // FU-A HEADER, 并将这个HEADER填入sendbuf[12]
            sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) (r[0] & 0x80)) << 7);
            sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
            sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) (r[0] & 0x1f)));
            // 同理将sendbuf[13]赋给nalu_payload
            //NALU头已经写到sendbuf[12]中，接下来则存放的是NAL的第一个字节之后的数据。所以从r的第二个字节开始复制
            System.arraycopy(r, 1, sendbuf, 13+psize, h264len - 1);
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4+psize, 4);//序列号接下来是时间戳，4个字节，存储后也需要倒序
            {
                byte temp = 0;
                temp = sendbuf[4+psize];
                sendbuf[4+psize] = sendbuf[7+psize];
                sendbuf[7+psize] = temp;
                temp = sendbuf[5+psize];
                sendbuf[5+psize] = sendbuf[6+psize];
                sendbuf[6+psize] = temp;
            }
            bytes = h264len + 12+psize;//获sendbuf的长度,为nalu的长度(包含nalu头但取出起始前缀,加上rtp_header固定长度12个字节)
//            client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
            System.out.println("小于包长"+sendbuf.length);

            outputStream.write(sendbuf);
            //send(sendbuf,bytes);

        } else if (h264len > packageSize) {
            int k = 0, l = 0;
            k = h264len / packageSize;
            l = h264len % packageSize;
            int t = 0;
            ts_current = ts_current + timestamp_increse;
            System.arraycopy(intToByte(ts_current), 0, sendbuf, 4+psize, 4);//时间戳，并且倒序
            {
                byte temp = 0;
                temp = sendbuf[4+psize];
                sendbuf[4+psize] = sendbuf[7+psize];
                sendbuf[7+psize] = temp;
                temp = sendbuf[5+psize];
                sendbuf[5+psize] = sendbuf[6+psize];
                sendbuf[6+psize] = temp;
            }
            while (t <= k) {
                System.arraycopy(intToByte(seq_num++), 0, sendbuf, 2+psize, 2);//序列号，并且倒序
                {
                    byte temp = 0;
                    temp = sendbuf[3+psize];
                    sendbuf[3+psize] = sendbuf[2+psize];
                    sendbuf[2+psize] = temp;
                }
                if (t == 0) {//分包的第一片
                    System.out.println("分包的第一片");
                    sendbuf[1+psize] = (byte) (sendbuf[1+psize] & 0x7F);//其值为：01100000，不是最后一片，M位（第一位）设为0
                    //FU indicator，一个字节，紧接在RTP header之后，包括F,NRI，header
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) (r[0] & 0x80)) << 7);//禁止位，为0
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) ((r[0] & 0x60) >> 5)) << 5);//NRI，表示包的重要性
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | (byte) (28));//TYPE，表示此FU-A包为什么类型，一般此处为28
                    //FU header，一个字节，S,E，R，TYPE
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0xBF);//E=0，表示是否为最后一个包，是则为1
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0xDF);//R=0，保留位，必须设置为0
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] | 0x80);//S=1，表示是否为第一个包，是则为1
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] | ((byte) (r[0] & 0x1f)));//TYPE，即NALU头对应的TYPE
                    //将除去NALU头剩下的NALU数据写入sendbuf的第14个字节之后。前14个字节包括：12字节的RTP Header，FU indicator，FU header
                    System.arraycopy(r, 1, sendbuf, 14+psize, packageSize);
                    //client.send(new DatagramPacket(sendbuf, packageSize+14, addr, port/*9200*/));
                    outputStream.write(sendbuf);
                    t++;
                } else if (t == k) {//分片的最后一片
                    System.out.println("分片的最后一片");

                    sendbuf[1+psize] = (byte) (sendbuf[1+psize] | 0x80);

                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) (r[0] & 0x80)) << 7);
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | (byte) (28));

                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0xDF); //R=0，保留位必须设为0
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0x7F); //S=0，不是第一个包
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] | 0x40); //E=1，是最后一个包
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] | ((byte) (r[0] & 0x1f)));//NALU头对应的type

                    if (0 != l) {//如果不能整除，则有剩下的包，执行此代码。如果包大小恰好是1400的倍数，不执行此代码。
                        System.out.println("如果不能整除，则有剩下的包，执行此代码");
                        System.arraycopy(r, t * packageSize + 1, sendbuf, 14+psize, l - 1);//l-1，不包含NALU头
                        bytes = l - 1 + 14+psize; //bytes=l-1+14;
                        //client.send(new DatagramPacket(sendbuf, bytes, addr, port/*9200*/));
                        outputStream.write(sendbuf);
                        //send(sendbuf,bytes);
                    }//pl
                    t++;
                } else if (t < k && 0 != t) {//既不是第一片，又不是最后一片的包
                    System.out.println("既不是第一片，又不是最后一片的包");

                    sendbuf[1+psize] = (byte) (sendbuf[1+psize] & 0x7F); //M=0，其值为：01100000，不是最后一片，M位（第一位）设为0.
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) (r[0] & 0x80)) << 7);
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | ((byte) ((r[0] & 0x60) >> 5)) << 5);
                    sendbuf[12+psize] = (byte) (sendbuf[12+psize] | (byte) (28));

                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0xDF); //R=0，保留位必须设为0
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0x7F); //S=0，不是第一个包
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] & 0xBF); //E=0，不是最后一个包
                    sendbuf[13+psize] = (byte) (sendbuf[13+psize] | ((byte) (r[0] & 0x1f)));//NALU头对应的type
                    System.arraycopy(r, t * packageSize + 1, sendbuf, 14+psize, packageSize);//不包含NALU头
                    //client.send(new DatagramPacket(sendbuf, packageSize+14, addr, port/*9200*/));
                    outputStream.write(sendbuf);
                    //send(sendbuf,1414);
                    t++;
                }
            }
        }
        //outputStream.flush();
    }
    public void sendData1(byte[] r, int h264len,OutputStream outputStream) throws IOException {

        outputStream.write(r);
//        outputStream.close();
    }

    public void packet_g711a(byte[] audioData, int audioLen,OutputStream outputStream) throws  Exception{
        RtpPacket rtp = new RtpPacket(255);
//        byte[] audio_data = new byte[400];
//        InputStream audio_stream = null;

//            //audio_stream = new FileInputStream("D:\\dianhui\\document\\GB28181\\mq.g711a");
//            while (audio_stream.read(audio_data) == 400) {
        byte[] payload = rtp.packet_g711a(audioData, audioLen);
        outputStream.write(payload);
        outputStream.flush();
        Thread.sleep(50);
//            }


    }

}